﻿#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<iostream>

using namespace std;

//int main()
//{
//	printf("hello world\n");
//
//	return 0;
//}

//#include<iostream>
//using namespace std;
//
//int main()
//{
//	cout << "hello world" << endl; //endl换行
//	cout << "hello world" << endl;
//
//	//printf("hello world\n");
//	//printf("hello world");
//
//	return 0;
//}





//一、命名空间namesapce

//int rand = 1;//rand是标准库stdlib.h中的函数，重复定义会报错
//命名空间可以定义变量，函数，类型
//namespace ax
//{
//	int rand = 1;//整数
//
//	int Add(int left, int right)
//	{
//		return left + right;
//	}//加法函数
//
//	struct Node
//	{
//		struct Node* next;
//		int val;
//	};//结构体类型
//}
//
//int main()
//{
//	printf("%p\n", rand);//这里默认函数rand的地址
//	printf("%p\n", ax::rand);//这里为命名空间里rand的地址
//
//	return 0;
//}

//可以嵌套
//namespace ax
//{
//	namespace al
//	{
//		int rand = 1;//整数
//		int add(int left, int right)
//		{
//			return left + right;
//		}//加法函数
//	}
//	namespace kx
//	{
//		int rand = 1;//整数
//		int add(int left, int right)
//		{
//			return left + right;
//		}//加法函数
//	}
//}
//int main()
//{
//	printf("%d\n", ax::al::rand);
//	printf("%d\n", ax::kx::rand);
//	printf("%d\n", ax::al::add(1, 2));
//	printf("%d\n", ax::kx::add(1, 2));
//	return 0;
//}









//多⽂件中可以定义同名namespace，他们会默认合并到⼀起，就像同⼀个namespace⼀样
#include"Queue.h"
#include"Stack.h"

// 全局定义了⼀份单独的Stack 

//typedef struct Stack
//
//{
//	int a[10];
//	int top;
//}ST;
//void STInit(ST* ps) {}
//void STPush(ST* ps, int x) {}
//
//int main()
//{
//	// 调⽤全局的 
//	ST st1;
//	STInit(&st1);
//	STPush(&st1, 1);
//	STPush(&st1, 2);
//	printf("%d\n", sizeof(st1));
//	// 调⽤bit namespace的 
//	bit::ST st2;
//	printf("%d\n", sizeof(st2));
//	bit::STInit(&st2, 1);
//	bit::STPush(&st2, 1);
//	bit::STPush(&st2, 2);
//	return 0;
//}
//大概意思懂了就行




//命名空间的使用
//namespace ax
//{
//	int a = 1;
//	int b = 2;
//}
//using namespace ax;//展开命名空间全部成员
//using ax::a;//展开命名空间指定成员
//int main()
//{
//	printf("%d\n",a);
//	return 0;
//}







//C++输入和输出
//C++的输⼊输出可以⾃动识别变量类型
////cout,cin,endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中
////所以要通过命名空间的使⽤⽅式去⽤他们
//int main()
//{
//	int a = 0;
//	double b = 3.14;
//	char c = 'x';
//	cout << a << " " << b << " " << c << endl;
//	std::cout << a << " " << b << " " << c << std::endl;
//
//	//scanf("%d%lf", &a, &b);
//	//printf("%d %lf", a, b);
//
//	cin >> a >> b >> c;
//	cout << a << " " << b << " " << c << endl;
//
//	return 0;
//}
//



//缺省参数

//void Func(int a = 1)//这里a = 1就是缺省参数
//{
//	cout << a << endl;
//}
//// 全缺省 
//void Func1(int a = 10, int b = 20, int c = 30)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//// 半缺省 
//void Func2(int a, int b = 10, int c = 20)
//{
//	cout << "a = " << a << endl;
//	cout << "b = " << b << endl;
//	cout << "c = " << c << endl << endl;
//}
//int main()
//{
//	Func();//未赋值的函数会使用缺省值
//	Func(10);
//
//	Func1();
//	Func2(1);
//	
//	return 0;
//}


//int main()
//{
//	ST s1;
//	STInit(&s1);
//	// 确定知道要插⼊1000个数据，初始化时⼀把开好，避免扩容 
//	ST s2;
//	STInit(&s2, 1000);
//	return 0;
//}

//缺省参数不能声明和定义同时给
//举例
//int Add(int a = 1, int b = 2);//函数声明，一般放在.h头文件中
//int Add(int a = 2, int b = 3)//函数定义，一般放在同名(方便查找).cpp实现
//{
//	return a + b;
//}
////这里不能同时给缺省参数,运行会报错说重定义默认参数
//int main()
//{
//	int n = Add();
//	cout << n << endl;
//
//	return 0;
//}




//引用,符号&与取地址同符号
//int main()
//{
//	int a = 0;
//	int& b = a;
//	int& c = a;
//	int& d = a;
//	
//	d++;
//
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//	cout << &d << endl;//结果是4个地址相同，表明b,c,d都是a的其他命名，或者说b,c,d就是a
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//
//	// 编译报错：“ra”: 必须初始化引⽤ 
//	//int& ra;//必须初始化
//
//	int& b = a;
//	int c = 20;
//	// 这⾥并⾮让b引⽤c，因为C++引⽤不能改变指向， 
//	// 这⾥是⼀个赋值 
//	b = c;
//	cout << &a << endl;
//	cout << &b << endl;
//	cout << &c << endl;
//	return 0;
//}




//void Swap(int& rx, int& ry)
//{
//	int tmp = rx;
//	rx = ry;
//	ry = tmp;
//}
//
//int main()
//{
//	int x = 0, y = 1;
//	cout << x << " " << y << endl;
//	Swap(x, y);
//	cout << x << " " << y << endl;
//	return 0;
//}




//int main()
//{
//	// 调⽤全局的 
//	ST st1;
//	STInit(st1);
//	STPush(st1, 1);
//	STPush(st1, 2);
//	cout << STTop(st1) << endl;
//	STTop(st1) += 10;
//	cout << STTop(st1) << endl;
//	return 0;
//}






//const引用
//int main()
//{
//	//const int a = 1;
//
//	////int& ra = a;//无法从const int 转换为 int &
//	////这⾥的引⽤是对a访问权限的放⼤
//
//	//const int& ra = a;//这样可以
//	////ra++;//报错,不能给常量赋值
//
//	//// 这⾥的引⽤是对b访问权限的缩⼩ 
//	//int b = 20;
//	//const int& rb = b;
//	////rb++; //编译报错：error C3892: “rb”: 不能给常量赋值
//	// 
//
//
//	int a = 10;
//
//	const int& ra = a;
//
//	//int& rb = a * 3;//⽆法从“int”转换为“int &”
//	//左值:a，有自己的存储地址，可以取地址&a
//	//右值:a+3,a*3等，临时值，只是一个计算结果，在计算完成后没有自己独立的存储位置
//	//而普通引用int&只能绑定左值(如变量)
//	const int& rb = a * 3;
//
//
//	double d = 12.34;
//	// 编译报错：“初始化”: ⽆法从“double”转换为“int &” 
//	// int& rd = d;
//
//	//常量引用,主要是存储原来变量的值，这里12.34int后为12，d改变rd不改变，rd不能改变
//	const int& rd = d;//把d从double类型转换为int类型然后储存，rd不能被更改
//	d++;//int&引用的话，rd是会改变的
//	cout << d << endl;
//	cout << rd << endl;
//
//
//	return 0;
//}



//inline内联函数
//inline int Add(int x, int y)
//{
//	int ret = x + y;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//	ret+=1;
//
//
//	return ret;
//}
//int main()
//{
//	int ret = Add(1, 2);
//	cout << ret << endl;
//
//	return 0;
//}




//nullptr
//void f(int x)
//{
//	cout << "f(int x)" << endl;
//}
//
//void f(int* ptr)
//{
//	cout << "f(int* ptr)" << endl;
//}
//
//int main()
//{
//	f(0);
//
//	f(NULL);
//	f((int*)NULL);
//
//	f(nullptr);
//
//	return 0;
//}


